package cn.utils;


import cn.hutool.core.collection.ListUtil;

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * 字符串工具类
 *
 * @author ruoyi
 */
public class StringUtils {


    /**
     * 替换特殊字符:+,./ ....
     *
     * @param chars 字符
     * @return {@link String }
     **/
    public static String toSpecialCharacters(String chars) {
        Pattern pattern = Pattern.compile("[^a-zA-Z0-9\\s\\u4e00-\\u9fa5]");
        Matcher matcher = pattern.matcher(chars);
        StringBuilder resultStr = new StringBuilder(chars);
        while (matcher.find()) {
            int start = matcher.start();
            resultStr.setCharAt(start, '-');
        }
        return resultStr.toString();
    }

    /**
     * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld
     *
     * @param name 转换前的下划线大写方式命名的字符串
     * @return 转换后的驼峰式命名的字符串
     */
    public static String convertToCamelCase(String name) {
        StringBuilder result = new StringBuilder();
        // 快速检查
        if (name == null || name.isEmpty()) {
            // 没必要转换
            return "";
        } else if (!name.contains("_")) {
            // 不含下划线，仅将首字母大写
            return name.substring(0, 1).toUpperCase() + name.substring(1);
        }
        // 用下划线将原始字符串分割
        String[] camels = name.split("_");
        for (String camel : camels) {
            // 跳过原始字符串中开头、结尾的下换线或双重下划线
            if (camel.isEmpty()) {
                continue;
            }
            // 首字母大写
            result.append(camel.substring(0, 1).toUpperCase());
            result.append(camel.substring(1).toLowerCase());
        }
        return result.toString();
    }


    public static boolean matches(String path, String pattern) {
        // 将路径模式转换为正则表达式
        String regex = path.replace(".", "\\.")
                .replace("*", ".*")
                .replace("?", ".");
        // 如果匹配成功，返回 true 如果没有匹配成功，返回 false
        return Pattern.matches(regex, pattern);
    }

    /**
     * 检查 path 是否与比较的地址中的任何模式匹配
     *
     * @param path     网址
     * @param patterns 比较的地址
     * @return boolean
     **/
    public static boolean matches(String path, List<String> patterns) {
        for (String pattern : patterns) {
            // 将路径模式转换为正则表达式
            String regex = path.replace(".", "\\.")
                    .replace("*", ".*")
                    .replace("?", ".");
            if (Pattern.matches(regex, pattern)) {
                return true; // 如果匹配成功，返回 true
            }
        }
        return false; // 如果没有匹配成功，返回 false
    }


    public static boolean matches(List<String> paths, List<String> patterns) {
        for (String path : paths) {
            for (String pattern : patterns) {
                // 将路径模式转换为正则表达式
                String regex = path.replace(".", "\\.")
                        .replace("*", ".*")
                        .replace("?", ".");
                if (Pattern.matches(regex, pattern)) {
                    return true; // 如果匹配成功，返回 true
                }
            }
        }
        return false; // 如果没有匹配成功，返回 false
    }

    public static boolean matches(List<String> paths, String... patterns) {
        return matches(paths, Arrays.stream(patterns).collect(Collectors.toList()));
    }

    public static boolean matches(String path, String... patterns) {
        return matches(new ArrayList<>(Collections.singleton(path)), Arrays.stream(patterns).collect(Collectors.toList()));
    }

    /**
     * 驼峰到下划线入 camelCaseToSnakeCase ----> camel_case_to_snake_case
     * 方法简介:
     * 业务背景:
     *
     * @param input 输入
     * @return {@link String }
     **/
    public static String camelCaseToSnakeCase(String input) {
        StringBuilder output = new StringBuilder();
        char[] chars = input.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char c = chars[i];
            if (Character.isUpperCase(c)) {
                if (i > 0 && Character.isLowerCase(chars[i - 1])) {
                    output.append('_');
                }
                output.append(Character.toLowerCase(c));
            } else {
                output.append(c);
            }
        }
        return output.toString();
    }

    public static void main(String[] args) {
        // 示例用法
        List<String> patterns = ListUtil.of("/mobile/getRelicInfoFilter");
        String path = "/mobile/**";

        System.out.println("Path matches: " + matches(path, patterns));
    }


}